import { getUserId,getToken } from "../../utils/storage"; // 导入获取userId的方法

Page({
  data: {
    currentTab: 'all',
    appointments: [], // 每条数据将包含数据库原始id
    cancelModalShow: false,
    currentCancelIndex: -1,
    cancelCount: 0, // 当天取消次数（当前用户）
    modalTitle: "取消预约",
    modalDesc: "取消3次后，该账号今日不可进行预约，是否还要继续？",
    isLoading: false,
    loadError: false,
    errorMsg: '',
    userId: '', // 存储当前用户ID（用于区分不同用户的取消次数）
    token:''
  },

  onLoad() {
    // 获取当前用户ID
    const token = getToken()
    this.setData({
      token: token // 将获取到的token存入data
    });
    const userId = getUserId();
    console.log('[调试] onLoad - 从storage获取的userId:', userId);
    if (!userId) {
      wx.showToast({ title: '用户信息获取失败，请重新登录', icon: 'none' });
      return;
    }
    this.setData({ userId });
    console.log('[调试] onLoad - 已设置userId:', userId);

    this.fetchAppointments();
  },

  // 获取预约列表（按remark=userId筛选）并检查过期记录
  fetchAppointments() {
    const { userId } = this.data;
    console.log('[调试] fetchAppointments - 开始加载预约列表，userId:', userId);
    if (!userId) {
      this.setLoadError('用户信息获取失败，请重新登录');
      return;
    }

    if (this.data.isLoading) {
      console.log('[调试] fetchAppointments - 正在加载中，忽略重复请求');
      return;
    }

    this.setData({ 
      isLoading: true,
      loadError: false,
      errorMsg: ''
    });
    wx.showLoading({ title: '加载预约列表...' });

    // 构造带userId（remark）参数的请求URL
    const apiUrl = `http://localhost:8080/appointment/appointment/list?remark=${encodeURIComponent(userId)}`;
    console.log('[调试] fetchAppointments - 请求URL:', apiUrl);

    wx.request({
      url: apiUrl,
      header:{
        Authorization: `Bearer ${this.data.token}`
      },
      method: 'GET',
      timeout: 10000,
      success: (res) => {
        console.log('[调试] fetchAppointments - 接口返回原始数据:', res);
        this.setData({ isLoading: false });
        wx.hideLoading();

        if (res.statusCode !== 200) {
          this.setLoadError(`服务器响应错误（状态码：${res.statusCode}）`);
          return;
        }

        if (res.data?.code !== 200) {
          this.setLoadError(`业务处理失败：${res.data?.msg || '未知错误'}`);
          return;
        }

        const responseData = res.data.rows;
        if (!Array.isArray(responseData)) {
          const dataType = typeof responseData;
          const dataValue = JSON.stringify(responseData);
          this.setLoadError(`数据格式错误：预期rows为数组，实际为${dataType}（值：${dataValue}）`);
          return;
        }

        // 格式化列表（保留原始预约时间用于时间对比）
        const formattedList = responseData.map((item, index) => {
          try {
            let dateStr = '';
            let timeStr = '';
            if (item.appointmentTime) {
              const timeParts = item.appointmentTime.split(' ');
              dateStr = timeParts[0] || '';
              timeStr = timeParts[1] || '';
            }
            const date = dateStr ? dateStr.replace(/-/g, '.') : '未知日期';
            const time = timeStr ? timeStr.slice(0, 5) : '未知时间';

            const typeNum = parseInt(item.appointmentType, 10);
            const type = isNaN(typeNum) ? '未知类型' : (typeNum === 0 ? '参观预约' : '探访预约');

            let phone = '未知手机号';
            if (item.mobile) {
              phone = item.mobile.length >= 7 
                ? item.mobile.replace(/(\d{3})\d+(\d{4})$/, '$1****$2') 
                : item.mobile;
            }

            const statusNum = parseInt(item.status, 10);
            const statusMap = { 0: '待上门', 1: '已完成', 2: '已取消', 3: '已过期' };
            const status = statusMap[statusNum] || '未知状态';

            let familyName;
            if (typeNum === 0) {
              familyName = item.extend2 || '未知家人';
            } else {
              familyName = item.elderName || '未知家人';
            }

            return {
              id: item.id, // 数据库原始id
              originalTime: item.appointmentTime, // 保留原始预约时间（用于时间对比）
              statusNum: statusNum, // 保留原始状态码（用于过期检测）
              date,
              time,
              type,
              phone,
              status,
              name: item.name || '未知姓名',
              familyName: familyName,
              remark: item.remark // 保留remark字段（用于核对）
            };
          } catch (err) {
            console.warn(`[调试] 第${index}条数据处理异常，已跳过：`, err);
            return null;
          }
        }).filter(Boolean);

        // 检查并更新过期预约（仅检测待上门数据）
        const updatedList = this.checkAndUpdateExpired(formattedList);

        this.setData({ appointments: updatedList });
        console.log('[调试] fetchAppointments - 预约列表加载完成，共', updatedList.length, '条数据');
        if (updatedList.length === 0) {
          wx.showToast({ title: '暂无该用户的预约数据', icon: 'none' });
        }
      },
      fail: (err) => {
        this.setData({ isLoading: false });
        wx.hideLoading();
        this.setLoadError(`网络请求失败：${err.errMsg}`);
        console.error('[调试] fetchAppointments - 请求失败详情：', err);
      }
    });
  },

  // 检查并更新过期预约（核心修改：仅检测状态为“待上门”的数据）
  checkAndUpdateExpired(list) {
    console.log('[调试] checkAndUpdateExpired - 开始检查过期预约，共', list.length, '条数据');
    const now = new Date().getTime(); // 当前时间戳（毫秒）
    const needUpdateIds = []; // 需要标记为过期的id列表
    const updatedList = [...list]; // 复制列表用于本地更新

    // 第一步：筛选出【待上门状态】且过期的记录
    updatedList.forEach((item, index) => {
      // 仅处理状态为“待上门”（statusNum=0）的数据
      if (item.statusNum !== 0) {
        console.log(`[调试] 跳过非待上门数据（id: ${item.id}，状态: ${item.status}）`);
        return; // 非待上门状态，直接跳过
      }

      // 解析预约时间为时间戳
      const appointmentDate = new Date(item.originalTime);
      const appointmentTimeStamp = appointmentDate.getTime();

      // 校验条件：预约时间有效 + 预约时间 < 当前时间（已过期）
      if (
        !isNaN(appointmentTimeStamp) && // 确保时间格式有效
        appointmentTimeStamp < now // 预约时间已过期
      ) {
        needUpdateIds.push({ id: item.id, index }); // 记录id和索引
        updatedList[index].status = '已过期'; // 本地标记为过期
        updatedList[index].statusNum = 3; // 更新状态码为“已过期”
        console.log(`[调试] 待上门数据已过期（id: ${item.id}），标记为已过期`);
      }
    });

    // 第二步：对过期的待上门记录调用接口更新状态
    if (needUpdateIds.length > 0) {
      console.log(`[调试] 发现${needUpdateIds.length}条过期的待上门预约，开始更新状态...`);
      needUpdateIds.forEach(({ id }) => {
        wx.request({
          url: 'http://localhost:8080/appointment/appointment',
          method: 'PUT',
          data: { id, status: 3 }, // 状态3：已过期
          header: { 'Content-Type': 'application/json',
            Authorization: `Bearer ${this.data.token}`
        },
          success: (res) => {
            if (res.statusCode === 200) {
              console.log(`[调试] 接口更新过期预约id=${id}成功`);
            } else {
              console.warn(`[调试] 接口更新过期预约id=${id}失败，状态码: ${res.statusCode}`);
            }
          },
          fail: (err) => {
            console.error(`[调试] 更新过期预约id=${id}网络失败：`, err);
          }
        });
      });
    } else {
      console.log('[调试] 无过期的待上门预约需更新');
    }

    return updatedList;
  },

  // 设置加载错误信息
  setLoadError(msg) {
    console.log('[调试] setLoadError - 错误信息:', msg);
    this.setData({
      loadError: true,
      errorMsg: msg,
      appointments: []
    });
    wx.showToast({ title: msg, icon: 'none', duration: 5000 });
  },

  // 重试加载
  retryLoad() {
    console.log('[调试] retryLoad - 用户点击重试加载');
    this.fetchAppointments();
  },

  // 显示取消弹窗
  showCancelModal(e) {
    const index = e.currentTarget.dataset.index;
    const { appointments, userId } = this.data;
    console.log('[调试] showCancelModal - 用户点击取消预约，索引:', index, 'userId:', userId);

    // 先查询当前用户的取消次数
    const countUrl = `http://localhost:8080/appointment/appointment/selectCancelCountByUserId/${userId}`;
    console.log('[调试] showCancelModal - 取消次数查询URL:', countUrl);
    
    wx.showLoading({ title: '加载取消次数...', mask: true });
    wx.request({
      url: countUrl,
      method: 'GET',
      header:{
        Authorization: `Bearer ${this.data.token}`
      },
      success: (res) => {
        console.log('[调试] showCancelModal - 取消次数查询响应:', res);
        wx.hideLoading();
        
        // 只校验状态码（200即代表接口请求成功）
        if (res.statusCode !== 200) {
          console.error('[调试] 取消次数查询状态码异常:', res.statusCode);
          wx.showToast({ title: `取消次数查询失败（状态码：${res.statusCode}）`, icon: 'none' });
          return;
        }
        
        // 校验是否返回cancelCount字段
        if (res.data.cancelCount === undefined) {
          console.error('[调试] 取消次数查询返回数据缺少cancelCount:', res.data);
          wx.showToast({ title: '取消次数数据格式错误', icon: 'none' });
          return;
        }
        
        // 正常处理（直接使用返回的cancelCount）
        const cancelCount = parseInt(res.data.cancelCount, 10) || 0; // 转数字防异常
        console.log('[调试] showCancelModal - 获取到取消次数:', cancelCount);
        this.setData({ cancelCount });

        if (cancelCount >= 3) {
          wx.showToast({ title: '今日取消次数已达上限', icon: 'none' });
          return;
        }

        if (appointments[index]?.status !== '待上门') {
          wx.showToast({ title: '仅待上门状态可取消', icon: 'none' });
          return;
        }

        // 动态设置弹窗描述
        const desc = cancelCount < 3
          ? `取消3次后，该账号今日不可进行预约，当前已取消${cancelCount}次，是否继续？`
          : "该账号今日已不可进行预约，是否还要继续？";

        this.setData({
          cancelModalShow: true,
          currentCancelIndex: index,
          modalDesc: desc
        });
      },
      fail: (err) => {
        console.error('[调试] showCancelModal - 取消次数查询请求失败:', err);
        wx.hideLoading();
        wx.showToast({ title: `网络异常：${err.errMsg}`, icon: 'none' });
      }
    });
  },

  // 取消取消操作
  cancelCancel() {
    console.log('[调试] cancelCancel - 用户取消了取消操作');
    this.setData({ cancelModalShow: false, currentCancelIndex: -1 });
  },

  // 确认取消预约
  confirmCancel() {
    const { currentCancelIndex, appointments, userId } = this.data;
    console.log('[调试] confirmCancel - 用户确认取消，索引:', currentCancelIndex, 'userId:', userId);
    
    if (currentCancelIndex === -1 || !userId) return;

    const currentAppointment = appointments[currentCancelIndex];
    if (!currentAppointment?.id) {
      wx.showToast({ title: '获取预约ID失败', icon: 'none' });
      this.setData({ cancelModalShow: false });
      return;
    }
    const id = currentAppointment.id;
    console.log('[调试] confirmCancel - 要取消的预约ID:', id);

    wx.showLoading({ title: '取消中...', mask: true });

    // 先更新预约状态为已取消
    wx.request({
      url: 'http://localhost:8080/appointment/appointment',
      method: 'PUT',
      data: { id, status: 2 }, // 状态2：已取消
      header: { 'Content-Type': 'application/json',
        Authorization: `Bearer ${this.data.token}`
    },
      success: (res) => {
        console.log('[调试] confirmCancel - 更新预约状态响应:', res);
        
        // 状态码200即代表预约状态更新成功
        if (res.statusCode !== 200) {
          wx.hideLoading();
          wx.showToast({ title: `预约取消失败（状态码：${res.statusCode}）`, icon: 'none' });
          return;
        }

        // 再更新取消次数
        const updateUrl = `http://localhost:8080/appointment/appointment/updateCancelCountByUserId/${userId}`;
        console.log('[调试] confirmCancel - 更新取消次数URL:', updateUrl);
        
        wx.request({
          url: updateUrl,
          method: 'PUT',
          header:{
            Authorization: `Bearer ${this.data.token}`
          },
          success: (countRes) => {
            console.log('[调试] confirmCancel - 更新取消次数响应:', countRes);
            wx.hideLoading();
            
            // 只校验状态码，直接取返回的cancelCount
            if (countRes.statusCode === 200) {
              const newCancelCount = countRes.data.cancelCount !== undefined 
                ? parseInt(countRes.data.cancelCount, 10) 
                : 0;
              console.log('[调试] confirmCancel - 更新后取消次数:', newCancelCount);
              
              // 更新页面数据
              const newAppointments = [...appointments];
              newAppointments[currentCancelIndex].status = '已取消';
              newAppointments[currentCancelIndex].statusNum = 2; // 更新状态码为已取消
              this.setData({
                appointments: newAppointments,
                cancelModalShow: false,
                currentCancelIndex: -1,
                cancelCount: newCancelCount
              });
              wx.showToast({ 
                title: `取消成功`, 
                icon: 'success' 
              });
            } else {
              console.error('[调试] 更新取消次数状态码异常:', countRes.statusCode);
              wx.showToast({ 
                title: `取消次数更新失败（状态码：${countRes.statusCode}）`, 
                icon: 'none' 
              });
            }
          },
          fail: (countErr) => {
            wx.hideLoading();
            console.error('[调试] 更新取消次数请求失败:', countErr);
            wx.showToast({ 
              title: `次数更新失败：${countErr.errMsg}`, 
              icon: 'none' 
            });
          }
        });
      },
      fail: (err) => {
        wx.hideLoading();
        console.error('[调试] 取消预约状态请求失败:', err);
        wx.showToast({ title: `网络异常：${err.errMsg}`, icon: 'none' });
      }
    });
  },

  // 切换标签页
  switchTab(e) {
    const tab = e.currentTarget.dataset.tab;
    console.log('[调试] switchTab - 切换到标签:', tab);
    this.setData({ currentTab: tab });
  },

  // 返回上一页
  goBack() {
    console.log('[调试] goBack - 用户点击返回');
    wx.navigateBack({ delta: 1 });
  },

  // 取消预约入口
  cancelAppointment(e) {
    console.log('[调试] cancelAppointment - 取消预约入口调用');
    this.showCancelModal(e);
  }
});